{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d7d93c56",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import random\n",
    "from collections import deque\n",
    "import torch.optim as optim"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "271e8c8c",
   "metadata": {},
   "source": [
    "## 1.定义算法\n",
    "### 1.1 建立Actor网络、Critic网络和OU噪声类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "167b00e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    def __init__(self, n_states, n_actions, hidden_dim, init_w=3e-3):\n",
    "        '''\n",
    "        actor 模型的结构定义\n",
    "        Args:\n",
    "            n_states (int): 输入状态的维度\n",
    "            n_actions (int): 可执行动作的数量\n",
    "            hidden_dim (int): 隐含层数量\n",
    "            init_w (float, optional): 均匀分布初始化权重的范围\n",
    "        '''\n",
    "        super(Actor, self).__init__()\n",
    "        self.linear1 = nn.Linear(n_states, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, n_actions)\n",
    "\n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = torch.tanh(self.linear3(x))\n",
    "        return x\n",
    "\n",
    "\n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, n_states, n_actions, hidden_dim, init_w=3e-3):\n",
    "        '''\n",
    "        critic 模型的结构定义\n",
    "        Args:\n",
    "            n_states (int): 输入状态的维度\n",
    "            n_actions (int): 可执行动作的数量\n",
    "            hidden_dim (int): 隐含层数量\n",
    "            init_w (float, optional): 均匀分布初始化权重的范围\n",
    "        '''\n",
    "        super(Critic, self).__init__()\n",
    "\n",
    "        self.linear1 = nn.Linear(n_states + n_actions, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "        # 随机初始化为较小的值\n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(self, state, action):\n",
    "        # 按维数1拼接\n",
    "        x = torch.cat([state, action], 1)\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class OUNoise(object):\n",
    "    '''\n",
    "    构造 Ornstein–Uhlenbeck 噪声的类\n",
    "    '''\n",
    "\n",
    "    def __init__(self, action_space, mu=0.0, theta=0.15, max_sigma=0.3, min_sigma=0.3, decay_period=100000):\n",
    "        '''\n",
    "        初始化输入参数\n",
    "        Args:\n",
    "            action_space (Union[gym.spaces.box.Box, gym.spaces.discrete.Discrete]): env 中的 action_space\n",
    "            mu (float, optional): 噪声均值\n",
    "            theta (float, optional): 系统对噪声的扰动程度，theta 越大，噪声扰动越小\n",
    "            max_sigma (float, optional): 最大 sigma，用于更新衰变 sigma 值\n",
    "            min_sigma (float, optional): 最小 sigma，用于更新衰变 sigma 值\n",
    "            decay_period (int, optional): 衰变周期\n",
    "        '''\n",
    "        self.mu = mu\n",
    "        self.theta = theta\n",
    "        self.sigma = max_sigma\n",
    "        self.max_sigma = max_sigma\n",
    "        self.min_sigma = min_sigma\n",
    "        self.decay_period = decay_period\n",
    "        self.n_actions = action_space.shape[0]  # env环境中可执行动作的数量\n",
    "        self.low = action_space.low  # env环境中动作取值的最小值\n",
    "        self.high = action_space.high  # env环境中动作取值的最大值\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        '''\n",
    "        重置噪声\n",
    "        '''\n",
    "        self.obs = np.ones(self.n_actions) * self.mu  # reset the noise\n",
    "\n",
    "    def evolve_obs(self):\n",
    "        '''\n",
    "        更新噪声\n",
    "        Returns:\n",
    "            返回更新后的噪声值\n",
    "        '''\n",
    "        x = self.obs\n",
    "        dx = self.theta * (self.mu - x) + self.sigma * np.random.randn(self.n_actions)  # Ornstein–Uhlenbeck process\n",
    "        self.obs = x + dx\n",
    "        return self.obs\n",
    "\n",
    "    def get_action(self, action, t=0):\n",
    "        '''\n",
    "        根据输入的动作，输出加入 OU 噪声后的动作\n",
    "        Args:\n",
    "            action (array): 输入的动作值\n",
    "            t (int, optional): 当前环境已执行的帧数\n",
    "\n",
    "        Returns:\n",
    "            action (float): 返回加入 OU 噪声后的动作\n",
    "        '''\n",
    "        ou_obs = self.evolve_obs()\n",
    "        ## 根据env进程（t），通过设定的衰变周期（decay_period），进行更新衰变的sigma值\n",
    "        self.sigma = self.max_sigma - (self.max_sigma - self.min_sigma) * min(1.0, t / self.decay_period)\n",
    "        return np.clip(action + ou_obs, self.low, self.high)  # add noise to action"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "751ddbad",
   "metadata": {},
   "source": [
    "### 1.2 定义经验回放"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5b2a4268",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBufferQue:\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        '''_summary_\n",
    "        Args:\n",
    "            trainsitions (tuple): _description_\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer):\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # sequential sampling\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else:\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86a5b209",
   "metadata": {},
   "source": [
    "### 1.3 DDPG_HER算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0ae370ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DDPG_HER:\n",
    "    def __init__(self, cfg):\n",
    "        '''\n",
    "        构建智能体\n",
    "        Args:\n",
    "            cfg (class): 超参数类 AlgoConfig\n",
    "        '''\n",
    "        self.n_states = cfg.n_states\n",
    "        self.n_actions = cfg.n_actions\n",
    "        self.states_dim = cfg.n_states * 2\n",
    "        self.actions_dim = cfg.n_actions\n",
    "        self.action_space = cfg.action_space  # env 中的 action_space\n",
    "        self.ou_noise = OUNoise(self.action_space)  # 实例化 构造 Ornstein–Uhlenbeck 噪声的类\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.gamma = cfg.gamma\n",
    "        self.tau = cfg.tau\n",
    "        self.sample_count = 0  # 记录采样动作的次数\n",
    "        self.update_flag = False  # 标记是否更新网络\n",
    "        self.device = torch.device(cfg.device)\n",
    "        self.critic = Critic(self.states_dim, self.actions_dim, hidden_dim=cfg.critic_hidden_dim).to(self.device)\n",
    "        self.target_critic = Critic(self.states_dim, self.actions_dim, hidden_dim=cfg.critic_hidden_dim).to(self.device)\n",
    "        self.actor = Actor(self.states_dim, self.actions_dim, hidden_dim=cfg.actor_hidden_dim).to(self.device)\n",
    "        self.target_actor = Actor(self.states_dim, self    .actions_dim, hidden_dim=cfg.actor_hidden_dim).to(self.device).to(\n",
    "            self.device)\n",
    "        ## 将 critc 网络的参数赋值给target critic 网络\n",
    "        for target_param, param in zip(self.target_critic.parameters(), self.critic.parameters()):\n",
    "            target_param.data.copy_(param.data)\n",
    "        ## 将 actor 网络的参数赋值给target actor 网络\n",
    "        for target_param, param in zip(self.target_actor.parameters(), self.actor.parameters()):\n",
    "            target_param.data.copy_(param.data)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=cfg.critic_lr)\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=cfg.actor_lr)\n",
    "        self.memory = ReplayBufferQue(cfg.buffer_size)\n",
    "\n",
    "    def sample_action(self, state):\n",
    "        '''\n",
    "        根据输入的状态采样动作\n",
    "        Args:\n",
    "            state (array): 输入的状态\n",
    "\n",
    "        Returns:\n",
    "            action (float): 根据状态采样后的动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        action_tanh = self.actor(state)  # action_tanh is in [-1, 1]\n",
    "        # convert action_tanh to action in the original action space\n",
    "        action_scale = torch.FloatTensor((self.action_space.high - self.action_space.low) / 2.).to(self.device)\n",
    "        action_bias = torch.FloatTensor((self.action_space.high + self.action_space.low) / 2.).to(self.device)\n",
    "        action = action_scale * action_tanh + action_bias\n",
    "        action = action.cpu().detach().numpy()[0]\n",
    "        # add noise to action\n",
    "        action = self.ou_noise.get_action(action, self.sample_count)\n",
    "        return action\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        '''\n",
    "        根据输入的状态预测下一步的动作\n",
    "        Args:\n",
    "            state (array):  输入的状态\n",
    "\n",
    "        Returns:\n",
    "            action (float): 根据状态采样后的动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        action_tanh = self.actor(state)  # action_tanh is in [-1, 1]\n",
    "        # convert action_tanh to action in the original action space\n",
    "        action_scale = torch.FloatTensor((self.action_space.high - self.action_space.low) / 2.).to(self.device)\n",
    "        action_bias = torch.FloatTensor((self.action_space.high + self.action_space.low) / 2.).to(self.device)\n",
    "        action = action_scale * action_tanh + action_bias\n",
    "        action = action.cpu().detach().numpy()[0]\n",
    "        return action\n",
    "\n",
    "    def update(self):\n",
    "        ## 当经验回放池中的数量小于 batch_size 时，直接返回不更新\n",
    "        if len(self.memory) < self.batch_size:  # when memory size is less than batch size, return\n",
    "            return\n",
    "        else:\n",
    "            if not self.update_flag:\n",
    "                print(\"Begin to update!\")\n",
    "                self.update_flag = True\n",
    "        ## 从经验回放池中采样 batch_size 个样本\n",
    "        state, action, reward, next_state, done = self.memory.sample(self.batch_size)\n",
    "        ## 将状态、动作等 array 转为 tensor\n",
    "        state = torch.FloatTensor(np.array(state)).to(self.device)\n",
    "        next_state = torch.FloatTensor(np.array(next_state)).to(self.device)\n",
    "        action = torch.FloatTensor(np.array(action)).to(self.device)\n",
    "        reward = torch.FloatTensor(reward).unsqueeze(1).to(self.device)\n",
    "        done = torch.FloatTensor(np.float32(done)).unsqueeze(1).to(self.device)\n",
    "        ## 输入状态及通过 actor 网络 根据该状态输出的动作，计算 critic 网络输出的价值，类似于DQN中的q-value\n",
    "        policy_loss = self.critic(state, self.actor(state))\n",
    "        ## 计算均值作为 critic 网络的损失\n",
    "        policy_loss = -policy_loss.mean()\n",
    "        ## 根据下一个 timestamp 的状态用 target_actor 网络输出目标动作\n",
    "        next_action = self.target_actor(next_state)\n",
    "        ## 输入下一个 timestamp 的状态及目标动作，计算 target_critc 网络输出的目标价值\n",
    "        target_value = self.target_critic(next_state, next_action.detach())\n",
    "        ## 根据真实奖励更新目标价值\n",
    "        expected_value = reward + (1.0 - done) * self.gamma * target_value\n",
    "        expected_value = torch.clamp(expected_value, -np.inf, np.inf)\n",
    "        ## 输入状态和动作，用 critic 网络计算预估的价值\n",
    "        value = self.critic(state, action)\n",
    "        ## 将 critic 网络输出的价值和 target_critic输出并更新后的价值通过MSE进行损失计算\n",
    "        value_loss = nn.MSELoss()(value, expected_value.detach())\n",
    "        ## 更新 actor 网络参数\n",
    "        self.actor_optimizer.zero_grad()\n",
    "        policy_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "        ## 更新 critic 网络参数\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        value_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "        ## 通过软更新的方法，缓慢更新 target critic 网络的参数\n",
    "        for target_param, param in zip(self.target_critic.parameters(), self.critic.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.tau) +\n",
    "                param.data * self.tau\n",
    "            )\n",
    "        ## 通过软更新的方法，缓慢更新 target actor 网络的参数\n",
    "        for target_param, param in zip(self.target_actor.parameters(), self.actor.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.tau) +\n",
    "                param.data * self.tau\n",
    "            )\n",
    "\n",
    "    def save_model(self, fpath):\n",
    "        '''\n",
    "        保存模型\n",
    "        Args:\n",
    "            fpath (str): 模型存放路径\n",
    "        '''\n",
    "        from pathlib import Path\n",
    "        # create path\n",
    "\n",
    "        Path(fpath).mkdir(parents=True, exist_ok=True)\n",
    "        torch.save(self.actor.state_dict(), f\"{fpath}/actor_checkpoint.pt\")\n",
    "\n",
    "    def load_model(self, fpath):\n",
    "        '''\n",
    "        根据模型路径导入模型\n",
    "        Args:\n",
    "            fpath (str): 模型路径\n",
    "        '''\n",
    "        actor_ckpt = torch.load(f\"{fpath}/actor_checkpoint.pt\", map_location=self.device)\n",
    "        self.actor.load_state_dict(actor_ckpt)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f97ba88",
   "metadata": {},
   "source": [
    "## 2.模型训练与测试"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71d9c8ca",
   "metadata": {},
   "source": [
    "### 2.1 定义奖励计算函数和目标生成函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "63c27d26",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcu_reward(new_goal, state, action):\n",
    "    # direcly use observation as goal\n",
    "    goal_cos, goal_sin, goal_thdot = new_goal[0], new_goal[1], new_goal[2]\n",
    "    cos_th, sin_th, thdot = state[0], state[1], state[2]\n",
    "    costs = angle_normalize(np.arccos(goal_cos) - np.arccos(cos_th)) ** 2 + 0.1 * (goal_thdot - thdot) ** 2#+ (goal_sin - sin_th) ** 2 \n",
    "    reward = -costs\n",
    "    return reward\n",
    "\n",
    "def generate_goals(i, episode_cache, sample_num, sample_range = 200):\n",
    "    '''\n",
    "    Input: current steps, current episode transition's cache, sample number\n",
    "    Return: new goals sets\n",
    "    notice here only \"future\" sample policy\n",
    "    '''\n",
    "    end = (i+sample_range) if i+sample_range < len(episode_cache) else len(episode_cache)\n",
    "    epi_to_go = episode_cache[i:end]\n",
    "    if len(epi_to_go) < sample_num:\n",
    "        sample_trans = epi_to_go\n",
    "    else:\n",
    "        sample_trans = random.sample(epi_to_go, sample_num)\n",
    "    return [np.array(trans[3][:3]) for trans in sample_trans]#episode_cache.append((o,a,r,o2))\n",
    "\n",
    "def angle_normalize(x):\n",
    "    return ((x + np.pi) % (2 * np.pi)) - np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c11adf6",
   "metadata": {},
   "source": [
    "### 2.2 训练函数与测试函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d36d474e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg, env, agent):\n",
    "    print(\"开始训练！\")\n",
    "    rewards = [] # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # reward per episode\n",
    "        ep_step = 0\n",
    "        episode_cache = []\n",
    "        HER_SAMPLE_NUM = cfg.her_sample_num\n",
    "        update_every = cfg.update_every\n",
    "        state, _ = env.reset()  # 环境状态\n",
    "        # 随机构造目标\n",
    "        np.random.seed(cfg.seed)\n",
    "        costheta = np.random.rand()\n",
    "        sintheta = np.sqrt(1-costheta**2)\n",
    "        w = 2 * np.random.rand()\n",
    "        goal = np.array([costheta,sintheta,w])\n",
    "        state = np.concatenate((state, goal)) # 结合环境状态和目标，构造新状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = agent.sample_action(state)  # sample action\n",
    "            next_state, reward, terminated, _, info = env.step(\n",
    "                action)  # update env and return transitions under new_step_api of OpenAI Gym\n",
    "            next_state = np.concatenate((next_state, goal)) # 结合下一时间步环境状态和目标，构造新下一时间步状态\n",
    "            reward = calcu_reward(goal, state, action) # 根据目标、状态、动作计算HER奖励\n",
    "            episode_cache.append((state, action, reward, next_state)) # 缓存transitions，便于事后经验回放\n",
    "            agent.memory.push((state, action, reward,\n",
    "                               next_state, terminated))  # 将transitions存入经验缓存池\n",
    "            \n",
    "            state = next_state  # update next state for env\n",
    "            ep_reward += reward  #\n",
    "            if terminated:\n",
    "                break\n",
    "\n",
    "        # Hindsight replay: Important operation of HER\n",
    "        for i, transition in enumerate(episode_cache):\n",
    "            new_goals = generate_goals(i, episode_cache, HER_SAMPLE_NUM) # 根据future方法构造新目标\n",
    "            for new_goal in new_goals:\n",
    "                state, action = transition[0], transition[1] # 从transition提取具有目标的状态和动作\n",
    "                reward = calcu_reward(new_goal, state, action) # 根据新目标、状态、动作计算奖励值\n",
    "            \n",
    "                state, new_state = transition[0][:3], transition[3][:3] # 从transition提取不包含目标的状态和下一时间步状态\n",
    "                state = np.concatenate((state, new_goal)) # 结合环境状态和生成的新目标，构造新状态\n",
    "                new_state = np.concatenate((new_state, new_goal)) # 结合下一时间步环境状态和生成的新目标，构造新下一时间步状态\n",
    "                agent.memory.push((state, action, reward, new_state, False)) # 将新的transition存入经验缓存池\n",
    "\n",
    "\n",
    "        for _ in range(update_every):\n",
    "            agent.update()  # update agent\n",
    "        rewards.append(ep_reward)\n",
    "    print(\"完成训练！\")\n",
    "    return {'rewards':rewards}\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = [] # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # reward per episode\n",
    "        ep_step = 0\n",
    "        ep_frames = []\n",
    "        state, _ = env.reset(seed = cfg.seed)  # 环境状态\n",
    "        # 随机构造目标\n",
    "        costheta = np.random.rand()\n",
    "        sintheta = np.sqrt(1-costheta**2)\n",
    "        w = 2 * np.random.rand()\n",
    "        goal = np.array([costheta,sintheta,w])\n",
    "        state = np.concatenate((state, goal)) # 结合环境状态和目标，构造新状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            if cfg.render and cfg.render_mode == 'rgb_array': # 用于可视化\n",
    "                frame = env.render()[0]\n",
    "                ep_frames.append(frame)\n",
    "            action = agent.predict_action(state)  # sample action\n",
    "            next_state, reward, terminated, _, info= env.step(\n",
    "                action)  # update env and return transitions under new_step_api of OpenAI Gym\n",
    "            next_state = np.concatenate((next_state, goal)) # 结合下一时间步环境状态和目标，构造新下一时间步状态\n",
    "            state = next_state  # update next state for env\n",
    "            ep_reward += reward\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试！\")\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e1fbdcf",
   "metadata": {},
   "source": [
    "## 3.定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "76f98c25",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "import os\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "#     env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = gym.make(cfg.env_name) # 创建环境\n",
    "    all_seed(env,seed=cfg.seed)\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.shape[0]\n",
    "    print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n",
    "    # 更新n_states和n_actions到cfg参数中\n",
    "    setattr(cfg, 'n_states', n_states)\n",
    "    setattr(cfg, 'n_actions', n_actions) \n",
    "    setattr(cfg, 'action_space', env.action_space) \n",
    "    models = {\"actor\":Actor(n_states,n_actions,hidden_dim=cfg.actor_hidden_dim),\"critic\":Critic(n_states,n_actions,hidden_dim=cfg.critic_hidden_dim)}\n",
    "    memory = ReplayBufferQue(cfg.buffer_size) # 创建经验池\n",
    "    agent = DDPG_HER(cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dd0d993",
   "metadata": {},
   "source": [
    "## 4.设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "73280107",
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'DDPG_HER' # 算法名称\n",
    "        self.env_name = 'Pendulum-v1' # 环境名称\n",
    "        self.new_step_api = True # whether to use new step api of gym\n",
    "        self.wrapper = None # wrapper of environment\n",
    "        self.render = False # whether to render environment\n",
    "        self.render_mode = \"human\" # 渲染模式, \"human\" 或者 \"rgb_array\"\n",
    "        self.mode = \"train\" # train or test\n",
    "        self.mp_backend = \"mp\" # 多线程框架，ray或者mp(multiprocessing)，默认mp\n",
    "        self.seed = 0 # random seed\n",
    "        self.device = \"cpu\" # device to use\n",
    "        self.train_eps = 150 # number of episodes for training\n",
    "        self.test_eps = 20 # number of episodes for testing\n",
    "        self.eval_eps = 10 # number of episodes for evaluation\n",
    "        self.eval_per_episode = 5 # evaluation per episode\n",
    "        self.max_steps = 200 # max steps for each episode\n",
    "        self.gamma = 0.99  # 贴现因子，值越大，表示未来的收益占更大的比重\n",
    "        self.critic_lr = 1e-3  # critic 模型的学习率\n",
    "        self.actor_lr = 1e-3  # actor 模型的学习率\n",
    "        self.buffer_size = 10000  # 经验回放池的大小\n",
    "        self.batch_size = 128  # 训练 actor 及 critic 模型的 batch 大小\n",
    "        self.tau = 0.01  # 软更新参数，值越小，表示在更新目标网络参数时，参数变化越小\n",
    "        self.critic_hidden_dim = 256  # critic 网络的隐含层数\n",
    "        self.actor_hidden_dim = 256  # actor 网络的隐含参数\n",
    "        self.her_sample_num = 4 # her抽样数量\n",
    "        self.update_every = 100 # 每代更新次数\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,title=\"learning curve\"):\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{title}\")\n",
    "    plt.xlim(0, len(rewards), 10)  # 设置x轴的范围\n",
    "    plt.xlabel('episodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd88f06a",
   "metadata": {},
   "source": [
    "## 5.开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a9a9c226",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：3，动作空间维度：1\n",
      "开始训练！\n",
      "Begin to update!\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/20，奖励：-128.04\n",
      "回合：2/20，奖励：-128.30\n",
      "回合：3/20，奖励：-129.48\n",
      "回合：4/20，奖励：-130.01\n",
      "回合：5/20，奖励：-126.93\n",
      "回合：6/20，奖励：-127.98\n",
      "回合：7/20，奖励：-127.98\n",
      "回合：8/20，奖励：-127.61\n",
      "回合：9/20，奖励：-128.26\n",
      "回合：10/20，奖励：-128.51\n",
      "回合：11/20，奖励：-128.19\n",
      "回合：12/20，奖励：-129.65\n",
      "回合：13/20，奖励：-126.58\n",
      "回合：14/20，奖励：-128.95\n",
      "回合：15/20，奖励：-129.56\n",
      "回合：16/20，奖励：-127.86\n",
      "回合：17/20，奖励：-129.21\n",
      "回合：18/20，奖励：-128.38\n",
      "回合：19/20，奖励：-126.82\n",
      "回合：20/20，奖励：-127.75\n",
      "回合：21/20，奖励：-129.56\n",
      "回合：22/20，奖励：-129.54\n",
      "回合：23/20，奖励：-130.06\n",
      "回合：24/20，奖励：-127.77\n",
      "回合：25/20，奖励：-127.89\n",
      "回合：26/20，奖励：-130.18\n",
      "回合：27/20，奖励：-128.48\n",
      "回合：28/20，奖励：-129.29\n",
      "回合：29/20，奖励：-127.86\n",
      "回合：30/20，奖励：-129.84\n",
      "回合：31/20，奖励：-130.29\n",
      "回合：32/20，奖励：-129.77\n",
      "回合：33/20，奖励：-128.35\n",
      "回合：34/20，奖励：-129.85\n",
      "回合：35/20，奖励：-128.75\n",
      "回合：36/20，奖励：-129.19\n",
      "回合：37/20，奖励：-128.04\n",
      "回合：38/20，奖励：-129.90\n",
      "回合：39/20，奖励：-128.93\n",
      "回合：40/20，奖励：-129.63\n",
      "回合：41/20，奖励：-129.00\n",
      "回合：42/20，奖励：-127.84\n",
      "回合：43/20，奖励：-129.24\n",
      "回合：44/20，奖励：-128.16\n",
      "回合：45/20，奖励：-128.15\n",
      "回合：46/20，奖励：-129.37\n",
      "回合：47/20，奖励：-128.79\n",
      "回合：48/20，奖励：-129.82\n",
      "回合：49/20，奖励：-128.05\n",
      "回合：50/20，奖励：-128.17\n",
      "回合：51/20，奖励：-129.11\n",
      "回合：52/20，奖励：-127.84\n",
      "回合：53/20，奖励：-128.44\n",
      "回合：54/20，奖励：-127.78\n",
      "回合：55/20，奖励：-128.50\n",
      "回合：56/20，奖励：-128.22\n",
      "回合：57/20，奖励：-129.95\n",
      "回合：58/20，奖励：-127.97\n",
      "回合：59/20，奖励：-129.15\n",
      "回合：60/20，奖励：-127.92\n",
      "回合：61/20，奖励：-127.61\n",
      "回合：62/20，奖励：-127.93\n",
      "回合：63/20，奖励：-127.87\n",
      "回合：64/20，奖励：-128.84\n",
      "回合：65/20，奖励：-130.11\n",
      "回合：66/20，奖励：-128.50\n",
      "回合：67/20，奖励：-127.87\n",
      "回合：68/20，奖励：-129.69\n",
      "回合：69/20，奖励：-130.32\n",
      "回合：70/20，奖励：-128.18\n",
      "回合：71/20，奖励：-127.92\n",
      "回合：72/20，奖励：-127.88\n",
      "回合：73/20，奖励：-129.78\n",
      "回合：74/20，奖励：-128.25\n",
      "回合：75/20，奖励：-130.11\n",
      "回合：76/20，奖励：-130.31\n",
      "回合：77/20，奖励：-130.05\n",
      "回合：78/20，奖励：-130.00\n",
      "回合：79/20，奖励：-129.52\n",
      "回合：80/20，奖励：-126.73\n",
      "回合：81/20，奖励：-129.48\n",
      "回合：82/20，奖励：-128.71\n",
      "回合：83/20，奖励：-125.70\n",
      "回合：84/20，奖励：-128.04\n",
      "回合：85/20，奖励：-129.31\n",
      "回合：86/20，奖励：-129.30\n",
      "回合：87/20，奖励：-129.23\n",
      "回合：88/20，奖励：-129.08\n",
      "回合：89/20，奖励：-128.51\n",
      "回合：90/20，奖励：-128.59\n",
      "回合：91/20，奖励：-126.65\n",
      "回合：92/20，奖励：-129.98\n",
      "回合：93/20，奖励：-127.95\n",
      "回合：94/20，奖励：-127.01\n",
      "回合：95/20，奖励：-127.81\n",
      "回合：96/20，奖励：-129.87\n",
      "回合：97/20，奖励：-126.60\n",
      "回合：98/20，奖励：-128.01\n",
      "回合：99/20，奖励：-128.10\n",
      "回合：100/20，奖励：-129.87\n",
      "回合：101/20，奖励：-128.86\n",
      "回合：102/20，奖励：-129.97\n",
      "回合：103/20，奖励：-129.42\n",
      "回合：104/20，奖励：-127.86\n",
      "回合：105/20，奖励：-128.19\n",
      "回合：106/20，奖励：-128.27\n",
      "回合：107/20，奖励：-127.72\n",
      "回合：108/20，奖励：-128.08\n",
      "回合：109/20，奖励：-126.36\n",
      "回合：110/20，奖励：-130.29\n",
      "回合：111/20，奖励：-130.06\n",
      "回合：112/20，奖励：-129.56\n",
      "回合：113/20，奖励：-128.32\n",
      "回合：114/20，奖励：-127.14\n",
      "回合：115/20，奖励：-129.48\n",
      "回合：116/20，奖励：-127.83\n",
      "回合：117/20，奖励：-129.08\n",
      "回合：118/20，奖励：-129.40\n",
      "回合：119/20，奖励：-129.72\n",
      "回合：120/20，奖励：-129.80\n",
      "回合：121/20，奖励：-128.61\n",
      "回合：122/20，奖励：-128.15\n",
      "回合：123/20，奖励：-126.84\n",
      "回合：124/20，奖励：-129.82\n",
      "回合：125/20，奖励：-130.20\n",
      "回合：126/20，奖励：-128.23\n",
      "回合：127/20，奖励：-128.52\n",
      "回合：128/20，奖励：-130.03\n",
      "回合：129/20，奖励：-128.18\n",
      "回合：130/20，奖励：-129.11\n",
      "回合：131/20，奖励：-129.14\n",
      "回合：132/20，奖励：-130.19\n",
      "回合：133/20，奖励：-128.26\n",
      "回合：134/20，奖励：-130.12\n",
      "回合：135/20，奖励：-130.23\n",
      "回合：136/20，奖励：-128.77\n",
      "回合：137/20，奖励：-129.98\n",
      "回合：138/20，奖励：-128.69\n",
      "回合：139/20，奖励：-128.13\n",
      "回合：140/20，奖励：-129.39\n",
      "回合：141/20，奖励：-128.72\n",
      "回合：142/20，奖励：-125.82\n",
      "回合：143/20，奖励：-128.21\n",
      "回合：144/20，奖励：-129.29\n",
      "回合：145/20，奖励：-127.82\n",
      "回合：146/20，奖励：-129.33\n",
      "回合：147/20，奖励：-128.04\n",
      "回合：148/20，奖励：-129.95\n",
      "回合：149/20，奖励：-128.26\n",
      "回合：150/20，奖励：-128.51\n",
      "完成测试！\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  # 画出结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59684e18",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (tensorflowenv)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
